import express, { Request, Response, Router } from 'express';
import * as bcrypt from 'bcrypt';
import jwt from 'jsonwebtoken';
import { PrismaClient } from '@prisma/client';
import { ApiResponse } from '../../utils/response';
import { adminAuthMiddleware, requireSuperAdmin } from '../../middleware/adminAuth';

const router: Router = express.Router();
const prisma = new PrismaClient();

const JWT_SECRET = process.env.JWT_SECRET || 'korea-financial-system-secret-key';

// 管理员登录（支持管理员和普通用户）
router.post('/login', async (req: Request, res: Response): Promise<void> => {
  try {
    const { username, password } = req.body;

    // 验证必填字段
    if (!username || !password) {
      res.status(400).json(ApiResponse.error('로그인 정보를 입력해 주세요.'));
      return;
    }

    // 先查找管理员（使用 username）
    const admin = await prisma.admin.findUnique({
      where: { username }
    });

    if (admin) {
      // 是管理员，按原来的逻辑处理
      if (admin.status !== 'ACTIVE') {
        res.status(400).json(ApiResponse.error('계정이 비활성화되었습니다. 시스템 관리자에게 문의해 주세요.'));
        return;
      }

      const isPasswordValid = await bcrypt.compare(password, admin.password);
      if (!isPasswordValid) {
        res.status(400).json(ApiResponse.error('아이디 또는 비밀번호가 올바르지 않습니다.'));
        return;
      }

      const token = jwt.sign(
        {
          adminId: admin.id,
          username: admin.username,
          role: admin.role,
          userType: 'ADMIN',
          isPartner: admin.isPartner,
          partnerCode: admin.partnerCode
        },
        JWT_SECRET,
        { expiresIn: '8h' }
      );

      const { password: _, ...adminWithoutPassword } = admin;

      res.json(ApiResponse.success({
        user: adminWithoutPassword,
        token,
        userType: 'ADMIN'
      }, '로그인에 성공했습니다.'));
      return;
    }

    // 如果不是管理员，查找普通用户（使用 idNumber，和用户端保持一致）
    const user = await prisma.user.findUnique({
      where: { idNumber: username }  // 使用 idNumber 查找，保持和用户端登录一致
    });

    if (!user) {
      res.status(400).json(ApiResponse.error('로그인 정보가 올바르지 않습니다.'));
      return;
    }

    // 检查用户状态
    if (user.status !== 'ACTIVE') {
      res.status(400).json(ApiResponse.error('계정이 비활성화되었습니다. 시스템 관리자에게 문의해 주세요.'));
      return;
    }

    // 验证密码
    const isPasswordValid = await bcrypt.compare(password, user.password);
    if (!isPasswordValid) {
      res.status(400).json(ApiResponse.error('로그인 정보가 올바르지 않습니다.'));
      return;
    }

    // 生成JWT token（普通用户作为推荐人角色）
    const token = jwt.sign(
      {
        userId: user.id,
        idNumber: user.idNumber,
        role: 'REFERRER',  // 推荐人角色
        userType: 'USER'
      },
      JWT_SECRET,
      { expiresIn: '8h' }
    );

    // 返回用户信息（不包含密码和敏感信息）
    const { password: _, idNumber: _idNumber, birthDateFirst6: _birthDateFirst6, withdrawalAccount: _withdrawalAccount, ...userInfo } = user;

    res.json(ApiResponse.success({
      user: {
        ...userInfo,
        role: 'REFERRER'
      },
      token,
      userType: 'USER'
    }, '로그인에 성공했습니다.'));

  } catch (error) {
    console.error('로그인 오류:', error);
    res.status(500).json(ApiResponse.error('로그인에 실패했습니다. 잠시 후 다시 시도해 주세요.'));
  }
});

// 获取当前管理员/用户信息
router.get('/profile', adminAuthMiddleware, async (req: Request, res: Response): Promise<void> => {
  try {
    const userType = (req as any).userType;
    const adminId = (req as any).adminId;
    const userId = (req as any).userId;

    if (userType === 'ADMIN' && adminId) {
      // 管理员
      const admin = await prisma.admin.findUnique({
        where: { id: adminId },
        select: {
          id: true,
          username: true,
          name: true,
          role: true,
          status: true,
          createdAt: true,
          updatedAt: true
        }
      });

      if (!admin) {
        res.status(404).json(ApiResponse.error('관리자 정보가 존재하지 않습니다.'));
        return;
      }

      res.json(ApiResponse.success({
        ...admin,
        userType: 'ADMIN'
      }, '관리자 정보 조회에 성공했습니다.'));
    } else if (userType === 'USER' && userId) {
      // 推荐人（普通用户）
      const user = await prisma.user.findUnique({
        where: { id: userId },
        select: {
          id: true,
          username: true,
          name: true,
          referralCode: true,
          status: true,
          createdAt: true,
          updatedAt: true
        }
      });

      if (!user) {
        res.status(404).json(ApiResponse.error('사용자 정보가 존재하지 않습니다.'));
        return;
      }

      res.json(ApiResponse.success({
        ...user,
        role: 'REFERRER',
        userType: 'USER'
      }, '사용자 정보 조회에 성공했습니다.'));
    } else {
      res.status(400).json(ApiResponse.error('잘못된 요청입니다.'));
    }

  } catch (error) {
    console.error('정보 조회 오류:', error);
    res.status(500).json(ApiResponse.error('정보 조회에 실패했습니다.'));
  }
});

// 修改密码
router.post('/change-password', adminAuthMiddleware, async (req: Request, res: Response): Promise<void> => {
  try {
    const adminId = (req as any).adminId;
    const { oldPassword, newPassword } = req.body;

    if (!oldPassword || !newPassword) {
      res.status(400).json(ApiResponse.error('기존 비밀번호와 새 비밀번호는 모두 필수 입력입니다.'));
      return;
    }

    if (newPassword.length < 6) {
      res.status(400).json(ApiResponse.error('새 비밀번호는 최소 6자 이상이어야 합니다.'));
      return;
    }

    // 获取当前管理员信息
    const admin = await prisma.admin.findUnique({
      where: { id: adminId }
    });

    if (!admin) {
      res.status(404).json(ApiResponse.error('관리자를 찾을 수 없습니다.'));
      return;
    }

    // 验证旧密码
    const isOldPasswordValid = await bcrypt.compare(oldPassword, admin.password);
    if (!isOldPasswordValid) {
      res.status(400).json(ApiResponse.error('기존 비밀번호가 올바르지 않습니다.'));
      return;
    }

    // 加密新密码
    const hashedNewPassword = await bcrypt.hash(newPassword, 12);

    // 更新密码
    await prisma.admin.update({
      where: { id: adminId },
      data: {
        password: hashedNewPassword,
        updatedAt: new Date()
      }
    });

    res.json(ApiResponse.success(null, '비밀번호가 성공적으로 변경되었습니다.'));

  } catch (error) {
    console.error('비밀번호 변경 오류:', error);
    res.status(500).json(ApiResponse.error('비밀번호 변경에 실패했습니다.'));
  }
});

// 创建新管理员（仅超级管理员）
router.post('/create-admin', adminAuthMiddleware, requireSuperAdmin, async (req: Request, res: Response): Promise<void> => {
  try {
    const { username, password, name, role = 'OPERATOR' } = req.body;

    if (!username || !password || !name) {
      res.status(400).json(ApiResponse.error('아이디, 비밀번호, 이름은 모두 필수 입력입니다.'));
      return;
    }

    if (password.length < 6) {
      res.status(400).json(ApiResponse.error('비밀번호는 최소 6자 이상이어야 합니다.'));
      return;
    }

    // 检查用户名是否已存在
    const existingAdmin = await prisma.admin.findUnique({
      where: { username }
    });

    if (existingAdmin) {
      res.status(400).json(ApiResponse.error('이미 사용 중인 아이디입니다.'));
      return;
    }

    // 验证角色
    const validRoles = ['SUPER_ADMIN', 'ADMIN', 'OPERATOR'];
    if (!validRoles.includes(role)) {
      res.status(400).json(ApiResponse.error('유효하지 않은 역할입니다.'));
      return;
    }

    // 加密密码
    const hashedPassword = await bcrypt.hash(password, 12);

    // 创建管理员
    const newAdmin = await prisma.admin.create({
      data: {
        username,
        password: hashedPassword,
        name,
        role,
        status: 'ACTIVE'
      },
      select: {
        id: true,
        username: true,
        name: true,
        role: true,
        status: true,
        createdAt: true
      }
    });

    res.status(201).json(ApiResponse.success(newAdmin, '관리자가 성공적으로 생성되었습니다.'));

  } catch (error) {
    console.error('관리자 생성 오류:', error);
    res.status(500).json(ApiResponse.error('관리자 생성에 실패했습니다.'));
  }
});

// 获取管理员列表（仅超级管理员）
router.get('/admins', adminAuthMiddleware, requireSuperAdmin, async (req: Request, res: Response): Promise<void> => {
  try {
    const { page = 1, limit = 20, status, role } = req.query;

    const where: any = {};
    if (status) where.status = status;
    if (role) where.role = role;

    const admins = await prisma.admin.findMany({
      where,
      select: {
        id: true,
        username: true,
        name: true,
        role: true,
        status: true,
        createdAt: true,
        updatedAt: true
      },
      orderBy: { createdAt: 'desc' },
      skip: (Number(page) - 1) * Number(limit),
      take: Number(limit)
    });

    const total = await prisma.admin.count({ where });

    res.json(ApiResponse.success({
      admins,
      pagination: {
        page: Number(page),
        limit: Number(limit),
        total: Number(total),
        totalPages: Math.ceil(Number(total) / Number(limit))
      }
    }));

  } catch (error) {
    console.error('관리자 목록 조회 오류:', error);
    res.status(500).json(ApiResponse.error('관리자 목록 조회에 실패했습니다.'));
  }
});

// 更新管理员상태（仅超级管理员）
router.post('/:id/status', adminAuthMiddleware, requireSuperAdmin, async (req: Request, res: Response): Promise<void> => {
  try {
    const { id } = req.params;
    const { status } = req.body;
    const currentAdminId = (req as any).adminId;

    // 본인 상태는 수정할 수 없습니다.
    if (parseInt(id) === currentAdminId) {
      res.status(400).json(ApiResponse.error('본인 상태는 수정할 수 없습니다.'));
      return;
    }

    const validStatuses = ['ACTIVE', 'INACTIVE', 'SUSPENDED'];
    if (!validStatuses.includes(status)) {
      res.status(400).json(ApiResponse.error('유효하지 않은 상태입니다.'));
      return;
    }

    const updatedAdmin = await prisma.admin.update({
      where: { id: parseInt(id) },
      data: { status },
      select: {
        id: true,
        username: true,
        name: true,
        role: true,
        status: true
      }
    });

    res.json(ApiResponse.success(updatedAdmin, '관리자 상태가 성공적으로 업데이트되었습니다.'));

  } catch (error) {
    console.error('관리자 상태 업데이트 오류:', error);
    res.status(500).json(ApiResponse.error('관리자 상태 업데이트에 실패했습니다.'));
  }
});

// 退出登录
router.post('/logout', adminAuthMiddleware, async (req: Request, res: Response): Promise<void> => {
  // JWT是없음상태的，客户端删除token即可
  res.json(ApiResponse.success(null, '로그아웃이 완료되었습니다.'));
});

export default router;